import OpenAI from 'openai'

// OpenAI客户端配置
const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
  baseURL: process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1',
})

// AI服务配置
const AI_CONFIG = {
  model: process.env.OPENAI_MODEL || 'gpt-3.5-turbo',
  maxTokens: 1000,
  temperature: 0.7,
}

// 解析OpenAI响应的JSON内容
function parseOpenAIResponse(response: string): any {
  let jsonContent = response.trim()
  
  // 如果响应包含Markdown代码块，提取其中的JSON
  if (jsonContent.includes('```json')) {
    const match = jsonContent.match(/```json\s*([\s\S]*?)\s*```/)
    if (match) {
      jsonContent = match[1].trim()
    }
  } else if (jsonContent.includes('```')) {
    // 处理没有json标记的代码块
    const match = jsonContent.match(/```\s*([\s\S]*?)\s*```/)
    if (match) {
      jsonContent = match[1].trim()
    }
  }
  
  return JSON.parse(jsonContent)
}

// 获取中国北京时间（UTC+8）的辅助函数
function getBeijingTime(): Date {
  const now = new Date()
  return new Date(now.getTime() + (8 * 60 * 60 * 1000))
}

// 将日期转换为北京时间格式字符串
function formatBeijingTime(date: Date): string {
  return date.toLocaleString('zh-CN', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit',
    hour12: false,
    timeZone: 'Asia/Shanghai'
  }).replace(/\//g, '-')
}

// 智能解析自然语言输入
export async function smartParse(text: string) {
  try {
    // 获取中国北京时间（UTC+8）
    const beijingTime = getBeijingTime()
    const currentYear = beijingTime.getUTCFullYear()
    const currentMonth = beijingTime.getUTCMonth() + 1
    const currentDay = beijingTime.getUTCDate()
    // 工作时间上下文（可从环境变量覆盖）
    const workStart = process.env.WORK_START || '09:00'
    const workEnd = process.env.WORK_END || '18:00'
    const tz = process.env.TZ || 'Asia/Shanghai'
    
    const prompt = `
你是一个高级智能任务管理助手，具备深度理解自然语言的能力。请运用你的AI智能来分析用户的真实意图，而不是简单的关键词匹配。

当前时间上下文：
- 当前日期：${currentYear}年${currentMonth}月${currentDay}日
- 当前时间：${beijingTime.toLocaleTimeString('zh-CN', { hour: '2-digit', minute: '2-digit', timeZone: 'Asia/Shanghai' })}
- 星期：${beijingTime.toLocaleDateString('zh-CN', { weekday: 'long', timeZone: 'Asia/Shanghai' })}
- 工作时间：${workStart}-${workEnd}（北京时间）
 - 时区：${tz}

用户输入: "${text}"

请深度分析用户的表达，理解其真实意图和情境，然后以JSON格式返回解析结果：

{
  "title": "提炼的任务标题（保留核心信息，去除时间修饰）",
  "dueDate": "智能推断的截止日期(YYYY-MM-DD HH:mm:ss格式，基于语义理解而非硬匹配，使用北京时间)",
  "priority": "基于任务性质和紧迫性智能判断的优先级(P1=高优先级/紧急, P2=正常优先级, P3=低优先级, P0保留给极度紧急)",
  "dueTime": "如果包含具体时间，解析为HH:MM格式（24小时制）",
  "category": "基于任务本质智能分类(work/learning/health/personal/other)",
  "tags": ["从语义中提取的相关标签"],
  "notes": "从用户表达中提取的额外信息和上下文",
  "isRecurring": "基于任务性质智能判断是否为重复任务",
  "recurringType": "如果是重复任务，智能推断重复频率",
  "recurringPattern": "如果是重复任务，描述重复模式",
  "suggestedSubtasks": [],
  "timeHints": {
    "hasTimeReference": "是否包含时间相关信息",
    "timeContext": "时间上下文分析",
    "urgencyLevel": "紧急程度评估"
  }
}

🧠 AI智能分析指导原则：

1. **语义理解优先**：
   - 理解用户的真实意图，而不是简单匹配关键词
   - 考虑语境、情感色彩、隐含信息
   - 分析任务的本质属性而非表面描述

2. **智能时间推断**：
   - "大后天" = 当前日期 + 3天（智能计算）
   - "下周某时" = 根据具体表达智能推断
   - "朋友生日" = 个人重要事件，可能需要提前准备
   - 包含时间词汇但无具体日期 = 根据任务性质和紧急程度智能判断

3. **智能优先级评估**：
   - P1 (高优先级): 紧急、重要、有deadline的任务，包括"紧急"、"重要"等关键词
   - P2 (正常优先级): 常规任务、个人事务、无特殊紧急性
   - P3 (低优先级): "有空时"、"可以延期"、非关键任务
   - P0 (极度紧急): 仅用于系统性危机或极度紧急的生死攸关情况，一般不使用
   
4. **精确时间解析**：
   - "下午5点" → "17:00"
   - "早上9点半" → "09:30" 
   - "晚上8点" → "20:00"
   - "中午12点" → "12:00"

5. **智能分类判断**：
   - 深度理解任务的本质属性
   - 考虑任务的主要目的和执行场景
   - "给朋友过生日" = 个人社交活动 → personal

6. **上下文感知**：
   - 考虑当前时间、季节、工作日/周末等因素
   - 理解用户的生活节奏和习惯
   - 智能推断最合理的执行时间

7. **EOD（下班前/今天结束前）语义推断**：
   - 当表述包含“下班前/收工前/今天结束前/今日截止/今天内完成”等EOD含义时，不要返回清晨或随机时间。
   - 推断为对应工作日的下班时间（${workEnd}）。
   - 若当前已过今天的下班时间，则顺延至下一个工作日的${workEnd}。
   - 若落在周末且明显为工作事项，则顺延至最近的工作日${workEnd}。
   - 输出尽量给出具体到分钟的时间（如 YYYY-MM-DDTHH:mm:00.000Z 或 YYYY-MM-DD HH:mm）。

示例智能分析：

示例1："大后天下午5点开会"
AI分析：工作会议，需要准时参加
输出：{
  "title": "开会",
  "dueDate": "${new Date(currentYear, currentMonth - 1, currentDay + 3).toISOString().split('T')[0]}",
  "dueTime": "17:00",
  "priority": "P1",
  "category": "work",
  "tags": ["会议", "工作"],
  "notes": "工作会议，需要准时参加",
  "isRecurring": false,
  "recurringType": null,
  "recurringPattern": null,
  "suggestedSubtasks": [],
  "timeHints": {
    "hasTimeReference": true,
    "timeContext": "大后天下午5点，具体时间明确",
    "urgencyLevel": "高"
  }
}

示例2："紧急处理客户投诉"
AI分析：包含"紧急"关键词，属于高优先级工作任务
输出：{
  "title": "处理客户投诉",
  "dueDate": "${new Date().toISOString().split('T')[0]}",
  "priority": "P1",
  "category": "work",
  "tags": ["客户服务", "紧急", "投诉处理"],
  "notes": "紧急客户投诉，需要及时处理",
  "isRecurring": false,
  "recurringType": null,
  "recurringPattern": null,
  "suggestedSubtasks": ["联系客户了解详情", "分析问题原因", "制定解决方案", "跟进处理结果"],
  "timeHints": {
    "hasTimeReference": false,
    "timeContext": "紧急任务，需要立即处理",
    "urgencyLevel": "极高"
  }
}

示例3："重要的项目汇报准备"  
AI分析：包含"重要"关键词，工作相关任务
输出：{
  "title": "项目汇报准备",
  "dueDate": "${new Date().toISOString().split('T')[0]}",
  "priority": "P1",
  "category": "work",
  "tags": ["项目", "汇报", "重要"],
  "notes": "重要的工作汇报，需要认真准备",
  "isRecurring": false,
  "recurringType": null,
  "recurringPattern": null,
  "suggestedSubtasks": ["收集项目数据", "制作PPT", "准备演讲稿", "预演汇报"],
  "timeHints": {
    "hasTimeReference": false,
    "timeContext": "重要工作任务，需要充分准备",
    "urgencyLevel": "高"
  }
}

请运用你的AI智能进行深度分析，只返回JSON格式结果。
`

    const completion = await openai.chat.completions.create({
      model: AI_CONFIG.model,
      messages: [
        {
          role: 'system',
          content: '你是一个专业的任务管理助手，擅长解析自然语言并提取任务信息。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      max_tokens: AI_CONFIG.maxTokens,
      temperature: AI_CONFIG.temperature,
    })

    const response = completion.choices[0]?.message?.content
    if (!response) {
      throw new Error('OpenAI API返回空响应')
    }

    console.log('🤖 OpenAI原始响应:', response)

    const result = parseOpenAIResponse(response)
    console.log('📊 解析后的结果:', JSON.stringify(result, null, 2))
    
    // 处理日期格式 + EOD 智能补时（仅在AI给到日期但未给时间时）
    const originalDueDate = result.dueDate
    if (result.dueDate) {
      const parsed = parseDateExpression(result.dueDate)
      // 如果AI输出没有具体时间（仅日期），并且备注/意图包含"下班""今天结束前"等EOD语义，则补齐到工作日结束时间
      const lower = JSON.stringify(result).toLowerCase()
      const containsEOD = /下班|收工|今天结束|今日结束|eod|end of day/.test(lower)
      if (parsed && containsEOD && !/\d{2}:\d{2}/.test(originalDueDate)) {
        try {
          const workEndStr = process.env.WORK_END || '18:00'
          const [h, m] = workEndStr.split(':').map(n => parseInt(n, 10))
          // 使用北京时间处理
          const beijingTime = new Date(parsed)
          const now = new Date()
          const beijingNow = new Date(now.getTime() + (8 * 60 * 60 * 1000))
          const isSameDay = beijingTime.toISOString().split('T')[0] === beijingNow.toISOString().split('T')[0]
          if (isSameDay && beijingNow.getUTCHours() * 60 + beijingNow.getUTCMinutes() > h * 60 + m) {
            beijingTime.setUTCDate(beijingTime.getUTCDate() + 1)
          }
          beijingTime.setUTCHours(h, m || 0, 0, 0)
          // 同步设置 dueTime，方便前端直接展示具体时间
          result.dueTime = `${String(h).padStart(2, '0')}:${String(m || 0).padStart(2, '0')}`
          // 存储为北京时间格式，与数据库时间处理保持一致
          result.dueDate = formatBeijingTime(beijingTime)
        } catch (e) {
          result.dueDate = parsed
        }
      } else {
        result.dueDate = parsed
      }
      console.log(`📅 日期处理: "${originalDueDate}" -> "${result.dueDate}"`)
    }

    return {
      success: true,
      result,
      message: 'AI智能解析完成',
      debug: process.env.DEBUG_AI_PROMPT === 'true' ? { prompt } : undefined
    }
  } catch (error) {
    console.error('OpenAI智能解析失败:', error)
    
    // 使用增强的fallback解析
    const fallbackResult = enhancedFallbackParse(text)
    
    return {
      success: true, // 改为true，因为我们提供了有效的解析结果
      result: fallbackResult,
      message: 'AI解析失败，使用基础解析结果',
      warning: error instanceof Error ? error.message : 'AI解析失败',
      debug: process.env.DEBUG_AI_PROMPT === 'true' ? { prompt: 'FALLBACK_ONLY (主请求失败未生成Prompt)' } : undefined
    }
  }
}

// 任务分解
export async function decomposeTask(title: string, description?: string) {
  try {
    // 获取中国北京时间（UTC+8）
    const currentTime = new Date()
    const beijingTime = new Date(currentTime.getTime() + (8 * 60 * 60 * 1000))
    
    const prompt = `
你是一个专业的任务分解专家。请将以下任务分解为具体的子任务。

当前时间: ${beijingTime.toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })}

任务标题: "${title}"
${description ? `任务描述: "${description}"` : ''}

请分析任务类型，并生成5-8个具体的、可执行的子任务。以JSON格式返回：

{
  "subtasks": [
    {
      "title": "子任务标题",
      "description": "子任务描述",
      "estimatedTime": "预估时间(如: 30分钟、2小时)",
      "dependencies": ["依赖的子任务标题"]
    }
  ],
  "analysis": "任务分析说明"
}

子任务要求：
1. 具体明确，可立即执行
2. 时间估算合理
3. 逻辑顺序清晰
4. 覆盖任务的所有方面
5. 考虑中国用户的工作习惯和时间安排

只返回JSON格式，不要其他文字。
`

    const completion = await openai.chat.completions.create({
      model: AI_CONFIG.model,
      messages: [
        {
          role: 'system',
          content: '你是一个专业的任务分解专家，擅长将复杂任务分解为可执行的子任务。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      max_tokens: AI_CONFIG.maxTokens,
      temperature: AI_CONFIG.temperature,
    })

    const response = completion.choices[0]?.message?.content
    if (!response) {
      throw new Error('OpenAI API返回空响应')
    }

    const result = parseOpenAIResponse(response)
    
    return {
      success: true,
      subtasks: result.subtasks.map((st: any) => ({
        ...st,
        id: generateId(),
        completed: false
      })),
      analysis: result.analysis,
      message: 'AI任务分解完成'
    }
  } catch (error) {
    console.error('OpenAI任务分解失败:', error)
    return {
      success: false,
      error: 'AI任务分解失败，请重试',
      fallback: generateFallbackSubtasks(title)
    }
  }
}

// 智能建议生成（增强版）
export async function generateSuggestions(tasks: any[], userContext?: string, behaviorContext?: string) {
  try {
    // 如果没有任务数据，返回基础建议
    if (!tasks || tasks.length === 0) {
      return {
        success: true,
        suggestions: generateFallbackSuggestions(),
        message: '没有任务数据，使用基础建议'
      }
    }

    // 获取中国北京时间（UTC+8）
    const beijingTime = getBeijingTime()
    const currentHour = beijingTime.getUTCHours()
    const currentDay = beijingTime.toLocaleDateString('zh-CN', { weekday: 'long', timeZone: 'Asia/Shanghai' })
    const timezone = 'Asia/Shanghai'
    
    // 分析任务数据，区分重复任务和普通任务
    const recurringTasks = tasks.filter(task => task.isRecurring)
    const regularTasks = tasks.filter(task => !task.isRecurring)
    const overdueTasks = tasks.filter(task => {
      if (!task.dueDate) return false
      // 处理北京时间格式的日期比较
      const dueDate = new Date(task.dueDate)
      const beijingDueDate = new Date(dueDate.getTime() + (8 * 60 * 60 * 1000))
      return beijingDueDate < beijingTime && !task.completed
    })
    
    // 计算时间上下文（基于北京时间）
    const timeContext = {
      currentTime: formatBeijingTime(beijingTime),
      timezone,
      isWeekend: beijingTime.getUTCDay() === 0 || beijingTime.getUTCDay() === 6,
      isWorkingHours: currentHour >= 9 && currentHour <= 18,
      currentHour,
      currentDay
    }
    
    const prompt = `
你是一个高级智能任务管理助手。请基于用户的任务数据和行为模式，生成个性化的智能建议。

🕐 时间上下文:
- 当前时间: ${formatBeijingTime(beijingTime)} (${currentDay} ${currentHour}:00)
- 时区: ${timezone}
- 是否周末: ${timeContext.isWeekend ? '是' : '否'}
- 是否工作时间: ${timeContext.isWorkingHours ? '是' : '否'}

📊 任务分析:
- 总任务数: ${tasks.length}
- 重复任务: ${recurringTasks.length}个
- 普通任务: ${regularTasks.length}个
- 过期任务: ${overdueTasks.length}个

📋 任务详情:
${tasks.map((task, index) => {
  const dueDate = task.dueDate ? new Date(task.dueDate) : null
  const timeToDue = dueDate ? Math.round((dueDate.getTime() - beijingTime.getTime()) / (1000 * 60 * 60)) : null
  const isOverdue = dueDate && dueDate < beijingTime && !task.completed
  
  return `${index + 1}. ${task.title}
     - 类型: ${task.isRecurring ? `重复任务(${task.recurringType})` : '普通任务'}
     - 优先级: ${task.priority}
     - 分类: ${task.category}
     - 状态: ${task.completed ? '已完成' : '进行中'}
     - 截止时间: ${task.dueDate || '无'}
     - 时间状态: ${isOverdue ? '已过期' : timeToDue ? `${timeToDue}小时后到期` : '无截止时间'}
     - 创建时间: ${task.createdAt}`
}).join('\n')}

${userContext ? `🎯 用户上下文: ${userContext}` : ''}

${behaviorContext ? `📈 用户行为分析:\n${behaviorContext}` : ''}

🧠 智能分析指导原则:

1. **任务类型区分**:
   - 重复任务: 关注习惯养成和规律性，避免建议合并或删除
   - 普通任务: 关注完成度和时间管理
   - 过期任务: 优先处理，建议调整时间或提升优先级

2. **时间感知建议**:
   - 工作时间: 建议工作相关任务
   - 非工作时间: 建议个人或学习任务
   - 周末: 建议休息和娱乐平衡
   - 过期任务: 立即提醒处理

3. **个性化考虑**:
   - 用户的工作习惯和偏好
   - 任务的紧急程度和重要性
   - 用户的历史完成率和拖延倾向
   - 季节性和周期性模式

基于以上信息，请生成2-3条高度个性化的智能建议。以JSON格式返回：

{
  "suggestions": [
    {
      "type": "建议类型",
      "message": "建议内容",
      "actions": [
        {
          "label": "操作按钮文字",
          "action": "操作类型",
          "primary": true/false
        }
      ],
      "taskId": "相关任务ID(如果有)",
      "reasoning": "建议原因和推理过程"
    }
  ]
}

建议类型说明：
- auto_schedule: 基于用户活跃时间的自动时间安排建议
- priority_adjustment: 基于紧急程度和用户习惯的优先级调整建议
- efficiency_tip: 基于用户行为模式的效率提升建议
- deadline_reminder: 基于用户拖延倾向的截止日期提醒
- workload_balance: 基于任务量和完成率的工作量平衡建议
- habit_optimization: 基于用户偏好的习惯优化建议
- overdue_alert: 过期任务提醒和处理建议
- recurring_task_management: 重复任务管理建议

⚠️ 重要提醒:
- 不要建议合并重复任务和普通任务
- 过期任务需要优先处理
- 考虑当前时间和用户状态
- 提供具体可操作的建议

请确保建议具体、可操作，并体现对用户行为模式的深度理解。只返回JSON格式，不要其他文字。
`

    const completion = await openai.chat.completions.create({
      model: AI_CONFIG.model,
      messages: [
        {
          role: 'system',
          content: '你是一个智能任务管理助手，擅长分析任务并提供个性化建议。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      max_tokens: AI_CONFIG.maxTokens,
      temperature: AI_CONFIG.temperature,
    })

    const response = completion.choices[0]?.message?.content
    if (!response) {
      throw new Error('OpenAI API返回空响应')
    }

    const result = parseOpenAIResponse(response)
    
    // 验证AI返回的结果格式
    if (!result.suggestions || !Array.isArray(result.suggestions)) {
      throw new Error('AI返回的建议格式不正确')
    }
    
    return {
      success: true,
      suggestions: result.suggestions.map((suggestion: any) => ({
        ...suggestion,
        id: generateId(),
        createdAt: new Date().toISOString()
      })),
      message: 'AI智能建议生成完成'
    }
  } catch (error) {
    console.error('OpenAI建议生成失败:', error)
    return {
      success: false,
      error: 'AI建议生成失败，请重试',
      fallback: generateFallbackSuggestions()
    }
  }
}

// 智能搜索
export async function intelligentSearch(query: string, tasks: any[]) {
  try {
    const prompt = `
你是一个智能搜索助手。请基于用户的搜索查询，理解搜索意图并提供相关建议。

搜索查询: "${query}"

可用任务数据:
${tasks.map((task, index) => 
  `${index + 1}. ${task.title} (优先级: ${task.priority}, 分类: ${task.category}, 标签: ${task.tags?.join(', ') || '无'}, 创建时间: ${task.createdAt})`
).join('\n')}

请分析搜索意图，并以JSON格式返回：

{
  "searchType": "搜索类型(priority/time/category/context)",
  "intent": "搜索意图分析",
  "suggestions": ["相关建议1", "相关建议2"],
  "relatedTasks": ["相关任务标题1", "相关任务标题2"],
  "searchTips": ["搜索技巧1", "搜索技巧2"]
}

搜索类型说明：
- priority: 优先级相关搜索
- time: 时间相关搜索
- category: 分类相关搜索
- context: 上下文相关搜索

只返回JSON格式，不要其他文字。
`

    const completion = await openai.chat.completions.create({
      model: AI_CONFIG.model,
      messages: [
        {
          role: 'system',
          content: '你是一个智能搜索助手，擅长理解用户搜索意图并提供相关建议。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      max_tokens: AI_CONFIG.maxTokens,
      temperature: AI_CONFIG.temperature,
    })

    const response = completion.choices[0]?.message?.content
    if (!response) {
      throw new Error('OpenAI API返回空响应')
    }

    const result = parseOpenAIResponse(response)
    
    return {
      success: true,
      ...result,
      message: 'AI智能搜索完成'
    }
  } catch (error) {
    console.error('OpenAI智能搜索失败:', error)
    return {
      success: false,
      error: 'AI搜索失败，请重试',
      fallback: generateFallbackSearch(query)
    }
  }
}

// 增强的智能fallback解析函数
function enhancedFallbackParse(text: string): any {
  // 获取中国北京时间（UTC+8）
  const now = new Date()
  const beijingTime = new Date(now.getTime() + (8 * 60 * 60 * 1000))
  const currentYear = beijingTime.getUTCFullYear()
  const currentMonth = beijingTime.getUTCMonth() + 1
  const currentDay = beijingTime.getUTCDate()
  
  console.log(`🧠 智能fallback解析: "${text}"`)
  
  // 基础解析结果
  const result = {
    title: text,
    dueDate: null as string | null,
    priority: 'P2' as string,
    category: 'personal' as string, // 默认改为personal，更符合个人任务管理
    tags: [] as string[],
    notes: '',
    isRecurring: false,
    recurringType: null as string | null,
    recurringPattern: null as string | null,
    suggestedSubtasks: [] as string[],
    timeHints: {
      hasTimeReference: false,
      timeContext: '',
      urgencyLevel: '普通'
    }
  }
  
  // 智能时间解析（修复大后天问题，使用北京时间）
  const timePatterns = [
    // 重要：大后天必须在后天之前检查！
    { pattern: /大后天/g, date: (() => {
      const threeDaysLater = new Date(beijingTime)
      threeDaysLater.setUTCDate(beijingTime.getUTCDate() + 3)
      result.timeHints.hasTimeReference = true
      result.timeHints.timeContext = '大后天 = 当前日期+3天'
      console.log(`📅 大后天日期计算: ${threeDaysLater.toISOString().split('T')[0]}`)
      return threeDaysLater.toISOString().split('T')[0]
    })() },
    // 今天
    { pattern: /今天/g, date: `${currentYear}-${currentMonth.toString().padStart(2, '0')}-${currentDay.toString().padStart(2, '0')}` },
    // 明天
    { pattern: /明天/g, date: (() => {
      const tomorrow = new Date(beijingTime)
      tomorrow.setUTCDate(beijingTime.getUTCDate() + 1)
      return tomorrow.toISOString().split('T')[0]
    })() },
    // 后天（注意：必须在大后天之后检查）
    { pattern: /后天/g, date: (() => {
      const dayAfter = new Date(beijingTime)
      dayAfter.setUTCDate(beijingTime.getUTCDate() + 2)
      return dayAfter.toISOString().split('T')[0]
    })() },
    // 下周
    { pattern: /下周|下个周/g, date: (() => {
      const nextWeek = new Date(beijingTime)
      nextWeek.setUTCDate(beijingTime.getUTCDate() + 7)
      return nextWeek.toISOString().split('T')[0]
    })() },
    // 下个月
    { pattern: /下个月/g, date: (() => {
      const nextMonth = new Date(beijingTime)
      nextMonth.setUTCMonth(beijingTime.getUTCMonth() + 1)
      return nextMonth.toISOString().split('T')[0]
    })() },
    // 具体时间词汇（如果没有明确日期，默认为今天）
    { 
      pattern: /(上午|下午|晚上|早上|中午)\s*\d{1,2}(点|时)\s*(半|\d{1,2}分?)?/g, 
      date: `${currentYear}-${currentMonth.toString().padStart(2, '0')}-${currentDay.toString().padStart(2, '0')}`,
      context: '包含具体时间，默认为今天'
    },
    // 具体日期格式：8月29日, 12月20日等
    { pattern: /(\d{1,2})月(\d{1,2})日/g, handler: (match: RegExpMatchArray) => {
      const month = parseInt(match[1])
      const day = parseInt(match[2])
      const targetDate = new Date(currentYear, month - 1, day)
      if (targetDate < beijingTime) {
        targetDate.setFullYear(currentYear + 1)
      }
      return targetDate.toISOString().split('T')[0]
    }}
  ]
  
  // 尝试匹配时间模式
  for (const timePattern of timePatterns) {
    if (timePattern.pattern.test(text)) {
      if ('date' in timePattern) {
        result.dueDate = timePattern.date || null
      } else if ('handler' in timePattern) {
        const match = text.match(timePattern.pattern)
        if (match) {
          result.dueDate = timePattern.handler(match)
        }
      }
      break
    }
  }
  
  // 优先级智能推断（基于语义和上下文）
  // 移除硬匹配，让AI主导优先级判断
  // 只在极少数明确情况下做fallback
  if (/紧急.*立即|马上.*重要|urgent.*now/i.test(text)) {
    result.priority = 'P1'
    console.log('🚨 检测到极高优先级关键词组合')
  }
  
  // 分类智能推断 - 减少硬匹配，优先让AI判断
  // 只保留最核心的明显分类线索
  if (/会议.*汇报|工作.*项目|公司.*业务/i.test(text)) {
    result.category = 'work'
    result.tags.push('工作')
    console.log('🏢 明确工作场景识别')
  } else if (/朋友.*生日|家人.*聚会|个人.*社交/i.test(text)) {
    result.category = 'personal'
    result.tags.push('个人')
    console.log('👥 明确个人社交识别')
  }
  // 其他分类交给AI智能判断
  
  // 特殊社交活动增强（避免重复处理）
  if (result.category === 'personal' && /生日/i.test(text) && !result.notes) {
    result.notes = '个人社交活动，可能需要准备礼物和安排'
    console.log('🎂 生日活动增强处理')
  }
  
  // 重复任务智能检测 - 只保留最明确的模式
  // 优先让AI判断，这里只处理极明确的情况
  if (/每天.*都要|天天.*必须|daily.*routine/i.test(text)) {
    result.isRecurring = true
    result.recurringType = 'daily'
    result.recurringPattern = '每天重复'
    result.tags.push('日常')
    console.log('📅 检测到明确的每日重复模式')
  } else if (/每周.*固定|weekly.*meeting|周会/i.test(text)) {
    result.isRecurring = true
    result.recurringType = 'weekly'
    result.recurringPattern = '每周重复'
    console.log('📅 检测到明确的每周重复模式')
  }
  // 其他重复模式交给AI智能判断
  
  // 智能标签提取 - 只保留高价值关键词
  // 减少硬编码，让AI主导标签生成
  const highValueKeywords = ['会议', 'PPT', '汇报', '培训', '项目']
  for (const keyword of highValueKeywords) {
    if (text.includes(keyword) && !result.tags.includes(keyword)) {
      result.tags.push(keyword)
    }
  }
  
  // 清理标题（移除时间信息，保留核心内容）
  let cleanTitle = text
    .replace(/今天|明天|后天|下周/g, '')
    .replace(/\d{1,2}月\d{1,2}日/g, '')
    .replace(/上午|下午|晚上/g, '')
    .replace(/\d{1,2}点\d{0,2}分?/g, '')
    .replace(/\s+/g, ' ')
    .trim()
  
  if (cleanTitle) {
    result.title = cleanTitle
  }
  
  return result
}

// 辅助函数
function parseDateExpression(dateStr: string): string | null {
  if (!dateStr) return null
  
  // 获取中国北京时间（UTC+8）
  const now = new Date()
  const beijingTime = new Date(now.getTime() + (8 * 60 * 60 * 1000))
  const currentYear = beijingTime.getUTCFullYear()
  
  // 处理相对日期（使用北京时间）
  if (dateStr.includes('今天')) {
    return beijingTime.toISOString().split('T')[0]
  } else if (dateStr.includes('明天')) {
    const tomorrow = new Date(beijingTime)
    tomorrow.setUTCDate(beijingTime.getUTCDate() + 1)
    return tomorrow.toISOString().split('T')[0]
  } else if (dateStr.includes('后天')) {
    const dayAfterTomorrow = new Date(beijingTime)
    dayAfterTomorrow.setUTCDate(beijingTime.getUTCDate() + 2)
    return dayAfterTomorrow.toISOString().split('T')[0]
  } else if (dateStr.includes('下周')) {
    const nextWeek = new Date(beijingTime)
    nextWeek.setUTCDate(beijingTime.getUTCDate() + 7)
    return nextWeek.toISOString().split('T')[0]
  } else if (dateStr.includes('这周')) {
    // 这周的某一天，默认设为3天后
    const thisWeek = new Date(beijingTime)
    thisWeek.setUTCDate(beijingTime.getUTCDate() + 3)
    return thisWeek.toISOString().split('T')[0]
  }
  
  // 处理完整日期格式 YYYY-MM-DD
  if (dateStr.match(/^\d{4}-\d{2}-\d{2}$/)) {
    const parsedDate = new Date(dateStr)
    const parsedYear = parsedDate.getFullYear()
    
    // 如果年份是2022或更早，且不是当前年份，则更新为当前年份或下一年
    if (parsedYear < currentYear) {
      parsedDate.setFullYear(currentYear)
      // 如果设置为当前年份后日期已过，则设为明年
      if (parsedDate < beijingTime) {
        parsedDate.setFullYear(currentYear + 1)
      }
    }
    
    return parsedDate.toISOString().split('T')[0]
  }
  
  // 处理只有月日的日期 MM-DD 或 M-D
  if (dateStr.match(/^\d{1,2}-\d{1,2}$/)) {
    const [month, day] = dateStr.split('-').map(num => parseInt(num))
    const targetDate = new Date(currentYear, month - 1, day)
    
    // 如果这个日期已经过去，设为明年
    if (targetDate < beijingTime) {
      targetDate.setFullYear(currentYear + 1)
    }
    
    return targetDate.toISOString().split('T')[0]
  }
  
  // 处理中文日期格式，如 "12月20日"
  const chineseDateMatch = dateStr.match(/(\d{1,2})月(\d{1,2})日/)
  if (chineseDateMatch) {
    const [, month, day] = chineseDateMatch
    const targetDate = new Date(currentYear, parseInt(month) - 1, parseInt(day))
    
    // 如果这个日期已经过去，设为明年
    if (targetDate < beijingTime) {
      targetDate.setFullYear(currentYear + 1)
    }
    
    return targetDate.toISOString().split('T')[0]
  }
  
  // 如果无法解析，返回null
  console.warn('无法解析日期表达式:', dateStr)
  return null
}

function generateId(): string {
  return Math.random().toString(36).substr(2, 9)
}

function generateFallbackSubtasks(title: string) {
  return [
    { id: generateId(), title: '分析需求', completed: false },
    { id: generateId(), title: '制定计划', completed: false },
    { id: generateId(), title: '执行实施', completed: false },
    { id: generateId(), title: '检查验证', completed: false },
    { id: generateId(), title: '总结复盘', completed: false }
  ]
}

function generateFallbackSuggestions() {
  return [
    {
      id: generateId(),
      type: 'efficiency_tip',
      message: '建议您定期回顾任务完成情况，优化工作流程。',
      actions: [
        { label: '好的', action: 'acknowledge', primary: true }
      ],
      createdAt: new Date().toISOString()
    },
    {
      id: generateId(),
      type: 'workload_balance',
      message: '根据您的任务情况，建议合理安排工作量，避免过度疲劳。',
      actions: [
        { label: '了解', action: 'acknowledge', primary: true }
      ],
      createdAt: new Date().toISOString()
    }
  ]
}

function generateFallbackSearch(query: string) {
  return {
    searchType: 'general',
    suggestions: ['尝试使用更具体的关键词', '按优先级或时间筛选'],
    searchTips: ['使用引号搜索精确短语', '添加时间范围限制']
  }
}

// 智能fallback参数解析
function intelligentFallbackParse(suggestion: any, action: string, taskContext?: any): any {
  // 获取中国北京时间（UTC+8）
  const beijingTime = getBeijingTime()
  const parameters: any = {}
  let reasoning = ''
  let confidence = 0.7
  let requiresUserInput = false
  let userPrompt = ''

  // 时间相关动作的智能解析
  if (action.includes('time') || action.includes('date') || action.includes('schedule')) {
    const content = suggestion.content || suggestion.message || ''
    
    // 智能时间解析（使用北京时间）
    if (content.includes('15:30') || content.includes('3:30')) {
      const targetDate = new Date(beijingTime)
      targetDate.setUTCHours(15, 30, 0, 0)
      parameters.dueDate = formatBeijingTime(targetDate)
      reasoning = '从建议内容中识别到具体时间15:30（北京时间）'
      confidence = 0.9
    } else if (content.includes('明天')) {
      const targetDate = new Date(beijingTime)
      targetDate.setUTCDate(beijingTime.getUTCDate() + 1)
      targetDate.setUTCHours(10, 0, 0, 0) // 默认上午10点
      parameters.dueDate = formatBeijingTime(targetDate)
      reasoning = '识别到"明天"，设置为明天上午10点（北京时间）'
      confidence = 0.8
    } else if (content.includes('下午') || content.includes('PM')) {
      const targetDate = new Date(beijingTime)
      targetDate.setUTCHours(14, 0, 0, 0) // 默认下午2点
      parameters.dueDate = formatBeijingTime(targetDate)
      reasoning = '识别到下午时间，设置为下午2点（北京时间）'
      confidence = 0.7
    } else {
      requiresUserInput = true
      userPrompt = '请输入新的截止日期和时间 (YYYY-MM-DD HH:MM):'
      reasoning = '无法从建议内容中识别具体时间，需要用户输入'
      confidence = 0.3
    }
  }

  // 优先级相关动作的智能解析
  if (action.includes('priority') || action.includes('urgent')) {
    const content = suggestion.content || suggestion.message || ''
    
    if (content.includes('P0') || content.includes('紧急') || content.includes('urgent')) {
      parameters.priority = 'P0'
      reasoning = '识别到紧急优先级要求'
      confidence = 0.9
    } else if (content.includes('P1') || content.includes('高优先级')) {
      parameters.priority = 'P1'
      reasoning = '识别到高优先级要求'
      confidence = 0.8
    } else if (content.includes('P2') || content.includes('中优先级')) {
      parameters.priority = 'P2'
      reasoning = '识别到中优先级要求'
      confidence = 0.8
    } else if (content.includes('P3') || content.includes('低优先级')) {
      parameters.priority = 'P3'
      reasoning = '识别到低优先级要求'
      confidence = 0.8
    } else if (content.includes('提升') || content.includes('提高')) {
      // 智能提升优先级
      const currentPriority = taskContext?.priority || 'P2'
      const priorityMap = { 'P3': 'P2', 'P2': 'P1', 'P1': 'P0', 'P0': 'P0' }
      parameters.priority = priorityMap[currentPriority as keyof typeof priorityMap] || 'P1'
      reasoning = `基于当前优先级${currentPriority}智能提升`
      confidence = 0.8
    } else if (content.includes('降低')) {
      // 智能降低优先级
      const currentPriority = taskContext?.priority || 'P2'
      const priorityMap = { 'P0': 'P1', 'P1': 'P2', 'P2': 'P3', 'P3': 'P3' }
      parameters.priority = priorityMap[currentPriority as keyof typeof priorityMap] || 'P2'
      reasoning = `基于当前优先级${currentPriority}智能降低`
      confidence = 0.8
    }
  }

  // 状态相关动作的智能解析
  if (action.includes('status') || action.includes('complete') || action.includes('progress')) {
    const content = suggestion.content || suggestion.message || ''
    
    if (content.includes('完成') || content.includes('complete')) {
      parameters.status = 'completed'
      reasoning = '识别到完成状态要求'
      confidence = 0.9
    } else if (content.includes('进行') || content.includes('开始') || content.includes('progress')) {
      parameters.status = 'in_progress'
      reasoning = '识别到进行中状态要求'
      confidence = 0.8
    } else if (content.includes('准备') || content.includes('preparing')) {
      parameters.status = 'in_progress' // 将 'preparing' 映射到 'in_progress'
      reasoning = '识别到准备中状态要求，映射为进行中状态'
      confidence = 0.8
    }
  }

  // 提醒相关动作的智能解析
  if (action.includes('reminder') || action.includes('alarm')) {
    const content = suggestion.content || suggestion.message || ''
    
    if (content.includes('10分钟') || content.includes('10min')) {
      parameters.reminderMinutes = 10
      reasoning = '识别到10分钟提醒要求'
      confidence = 0.9
    } else if (content.includes('30分钟') || content.includes('30min')) {
      parameters.reminderMinutes = 30
      reasoning = '识别到30分钟提醒要求'
      confidence = 0.9
    } else if (content.includes('1小时') || content.includes('1hour')) {
      parameters.reminderMinutes = 60
      reasoning = '识别到1小时提醒要求'
      confidence = 0.9
    } else {
      parameters.reminderMinutes = 30 // 默认30分钟
      reasoning = '使用默认30分钟提醒'
      confidence = 0.5
    }
  }

  return {
    action,
    parameters,
    reasoning,
    confidence,
    requiresUserInput,
    userPrompt
  }
}

// 智能AI动作参数解析
export async function parseActionParameters(suggestion: any, action: string, taskContext?: any) {
  try {
    // 获取中国北京时间（UTC+8）
    const beijingTime = getBeijingTime()
    const currentHour = beijingTime.getUTCHours()
    const currentDay = beijingTime.toLocaleDateString('zh-CN', { weekday: 'long', timeZone: 'Asia/Shanghai' })
    
    const prompt = `
你是一个高级智能任务管理助手，专门负责解析AI建议动作的参数。

当前时间: ${formatBeijingTime(beijingTime)} (${currentDay} ${currentHour}:00)

AI建议内容: "${suggestion.content || suggestion.message}"
建议类型: ${suggestion.type || 'general'}
要执行的动作: ${action}

${taskContext ? `
相关任务信息:
- 任务标题: ${taskContext.title}
- 当前优先级: ${taskContext.priority}
- 当前状态: ${taskContext.completed ? '已完成' : '进行中'}
- 当前分类: ${taskContext.category}
- 当前截止时间: ${taskContext.dueDate}
` : ''}

请基于AI建议的内容和上下文，智能解析出执行该动作所需的参数。以JSON格式返回：

{
  "action": "${action}",
  "parameters": {
    "dueDate": "如果涉及时间调整，返回北京时间格式的日期时间字符串(YYYY-MM-DD HH:mm:ss)，否则为null",
    "priority": "如果涉及优先级调整，返回新的优先级(P0/P1/P2/P3)，否则为null", 
    "status": "如果涉及状态调整，返回新状态(todo/in_progress/review/done)，否则为null",
    "category": "如果涉及分类调整，返回新分类(work/personal/learning/health/other)，否则为null",
    "reminderMinutes": "如果涉及提醒设置，返回提醒提前分钟数，否则为null",
    "notes": "如果涉及备注更新，返回新的备注内容，否则为null"
  },
  "reasoning": "解释为什么这样解析参数",
  "confidence": "解析的置信度(0-1)",
  "requiresUserInput": "是否需要用户进一步确认或输入",
  "userPrompt": "如果需要用户输入，提供友好的提示文本"
}

🧠 智能解析指导原则：

1. **时间智能推断**（基于北京时间）：
   - "调整到15:30" → dueDate: 今天的15:30（北京时间）
   - "明天下午3点" → dueDate: 明天的15:00（北京时间）
   - "推迟到下周" → dueDate: 下周一的当前时间（北京时间）
   - "提前到上午" → dueDate: 今天的上午10:00（北京时间）

2. **优先级智能调整**：
   - "提升优先级" → 根据当前优先级智能提升一级
   - "设为紧急" → priority: "P0"
   - "降低优先级" → 根据当前优先级智能降低一级

3. **状态智能转换**：
   - "开始执行" → status: "in_progress"
   - "标记完成" → status: "done"
   - "准备中" → status: "in_progress"
   - "待处理" → status: "todo"
   - "审核中" → status: "review"

4. **上下文感知**（基于北京时间）：
   - 考虑当前北京时间、任务性质、用户习惯
   - 避免设置不合理的时间（如过去的时间）
   - 根据任务紧急程度调整提醒时间
   - 所有时间计算都基于中国时区（UTC+8）

只返回JSON格式，不要其他文字。
`

    const completion = await openai.chat.completions.create({
      model: AI_CONFIG.model,
      messages: [
        {
          role: 'system',
          content: '你是一个智能任务管理助手，专门负责解析AI建议动作的参数。'
        },
        {
          role: 'user',
          content: prompt
        }
      ],
      max_tokens: AI_CONFIG.maxTokens,
      temperature: 0.3, // 降低温度以获得更一致的解析结果
    })

    const response = completion.choices[0]?.message?.content
    if (!response) {
      throw new Error('OpenAI API返回空响应')
    }

    console.log('🤖 AI动作参数解析原始响应:', response)

    const result = parseOpenAIResponse(response)
    
    // 验证解析结果
    if (!result.parameters || typeof result.parameters !== 'object') {
      throw new Error('AI返回的参数格式不正确')
    }

    console.log('📊 AI动作参数解析结果:', JSON.stringify(result, null, 2))
    
    return {
      success: true,
      result,
      message: 'AI智能参数解析完成'
    }
  } catch (error) {
    console.error('AI动作参数解析失败:', error)
    
    // 使用智能fallback解析
    const fallbackResult = intelligentFallbackParse(suggestion, action, taskContext)
    
    return {
      success: true,
      result: fallbackResult,
      message: 'AI解析失败，使用智能fallback解析',
      warning: error instanceof Error ? error.message : 'AI解析失败'
    }
  }
}

// 批量解析多个动作参数
export async function batchParseActionParameters(suggestions: any[], taskContext?: any) {
  const results = []
  
  for (const suggestion of suggestions) {
    if (suggestion.actions && Array.isArray(suggestion.actions)) {
      for (const action of suggestion.actions) {
        try {
          const result = await parseActionParameters(suggestion, action.action, taskContext)
          results.push({
            suggestionId: suggestion.id,
            action: action.action,
            ...result
          })
        } catch (error) {
          console.error(`解析动作参数失败: ${action.action}`, error)
          results.push({
            suggestionId: suggestion.id,
            action: action.action,
            success: false,
            error: error instanceof Error ? error.message : '解析失败'
          })
        }
      }
    }
  }
  
  return results
}
